package logica_de_negocio;

import java.util.HashSet;

import comun.Usuario;
import logica_de_datos.GestorBD;

public class gestorUsuario {

	protected HashSet<Usuario> listaUsuario;
	final GestorBD objConversor = GestorBD.getInstance();

	public gestorUsuario() {

		listaUsuario = new HashSet<Usuario>();
	}

	public void cargarDatos() throws ClassNotFoundException {// CARGAMOS LO
																// ALMACENADO EN
																// EL HASHSET

		objConversor.connect();
		listaUsuario = objConversor.listarUsuario();
		objConversor.disconnect();

	}

	public void anadiUsu(int id_i, String usuario, String passWord,
			boolean isAdmin) throws excepAnadirDupli, ClassNotFoundException {

		cargarDatos();
		Usuario usu = new Usuario(0, id_i, usuario, passWord, isAdmin);

		if (listaUsuario.contains(usu)) {
			excepAnadirDupli dupli = new excepAnadirDupli();
			dupli.setDes("El usuario con " + usu.getUsuario()
					+ " nombre esta ya en la base de datos ");
			throw dupli;
		} else {
			try {
				objConversor.connect();
				objConversor.addUsuario(usu);
				objConversor.disconnect();
			} catch (ClassNotFoundException e) {
			}
		}
	}

	public boolean comprobar(String usuario, String passWord)
			throws ClassNotFoundException {

		// PRIMERO ACTUALIZAMOS LOS DATOS
		cargarDatos();
		boolean dev = false;
		for (Usuario a : listaUsuario) {

			if (a.getUsuario().equals(usuario)) {

				if (a.getPassWord().equals(passWord)) {
					dev = true;
				}
			}

		}
		return dev;
	}

	public boolean libre(String usuario) throws ClassNotFoundException {// NOS
																		// INDICA
																		// MENDIANTE
																		// UN
																		// TRUE
																		// O
		// FALSE SI EL USUARIO ELEGIDO ESTA
		// DISPONIBLE
		// PRIMERO ACTUALIZAMOS LOS DATOS
		cargarDatos();

		boolean libre = true;
		for (Usuario u : listaUsuario) {

			if (u.getUsuario().equals(usuario))
				libre = false;

		}

		return libre;
	}

	public boolean adminPorDefecto() throws ClassNotFoundException {

		boolean dev = false;

		if (thereAreNotAdmin()) {
			try {
				anadiUsu(0, "jep", "jep", true);
			} catch (excepAnadirDupli e) {
			}
			dev = true;
		} else {
			dev = false;
		}
		return dev;

	}

	private boolean thereAreNotAdmin() throws ClassNotFoundException {

		cargarDatos();
		boolean dev = true;

		for (Usuario u : listaUsuario) {
			if (u.isEsAdmin()) {
				dev = false;
			}
		}
		return dev;
	}

	public boolean borrar(int id_u, ExcepDeleteOnCascade e)
			throws ExcepDeleteOnCascade, ClassNotFoundException {

		// PRIMERO ACTUALIZAMOS LOS DATOS
		cargarDatos();
		boolean corec = false;

		gestorValoracionPelicula gvp = new gestorValoracionPelicula();
		gestorValoracionCapitulo gvc = new gestorValoracionCapitulo();
		gestorPeliculaVistaNoSi gpvns = new gestorPeliculaVistaNoSi();
		gestorCapituloVistaNoSi gcvns = new gestorCapituloVistaNoSi();
		GestorSigueSerie gss = new GestorSigueSerie();

		boolean boolGVPisId_u = gvp.isId_u(id_u);
		boolean boolGVCisId_u = gvc.isId_u(id_u);
		boolean boolGPVNSisId_u = gpvns.isId_u(id_u);
		boolean boolGCVNSisId_u = gcvns.isId_u(id_u);
		boolean boolgssisId_u = gss.isId_u(id_u);

		boolean permitido = e.isAceptado();
		if (permitido == false) {
			if ((boolGVPisId_u) || (boolGVCisId_u) || (boolGPVNSisId_u)
					|| (boolGVCisId_u) || (boolgssisId_u)) {
				throw e;
			} else {
				permitido = true;
			}
		}
		if (permitido) {
			boolean borGvp = false;
			if (boolGVPisId_u) {
				borGvp = gvp.deleteAllValoracionPeliculaFromId_U(id_u);
			} else {
				borGvp = true;
			}

			boolean borGvc = false;
			if (boolGVCisId_u) {
				borGvc = gvc.deleteAllValoracionCapituloFromId_U(id_u);
			} else {
				borGvc = true;
			}

			boolean borGpvns = false;
			if (boolGPVNSisId_u) {
				borGpvns = gpvns.deleteAllPeliculaVistaNoSiFromId_U(id_u);
			} else {
				borGpvns = true;
			}

			boolean borGcvns = false;
			if (boolGCVNSisId_u) {
				borGcvns = gcvns.deleteAllCapituloVistaNoSiFromId_U(id_u);
			} else {
				borGcvns = true;
			}

			boolean borGss = false;
			if (boolgssisId_u) {
				borGss = gss.deleteAllSigueSerieFromId_u(id_u);
			} else {
				borGss = true;
			}

			if (borGss) {
				if (borGvp) {
					if (borGvc) {
						if (borGpvns) {
							if (borGcvns) {
								if (borrarFin(id_u)) {
									corec = true;
								}
							}
						}
					}
				}
			}
		}
		return corec;
	}

	private boolean borrarFin(int id_u) throws ClassNotFoundException {
		boolean borrado = false;

		objConversor.connect();
		objConversor.deleteUsuario(id_u);
		borrado = true;
		objConversor.disconnect();

		return borrado;
	}

	/**
	 * Cuando la imagen se borra se carga la imagen por defecto.
	 * 
	 * @param id_i
	 *            Id de la imagen que se ha borrado de la base de datos.
	 * @throws ClassNotFoundException
	 *             Si no se encuantra la base de datos
	 */
	public void imagenBorrada(int id_i) throws ClassNotFoundException {
		cargarDatos();

		for (Usuario u : listaUsuario) {
			if (u.getId_i() == id_i) {
				u.setId_i(0);
				objConversor.connect();
				objConversor.modifyUsuario(u);
				objConversor.disconnect();
			}
		}
	}

	public void modificarUsuario(Usuario u) throws ClassNotFoundException {
		objConversor.connect();
		objConversor.modifyUsuario(u);
		objConversor.disconnect();
	}

	public boolean estaVacia() throws ClassNotFoundException {

		// PRIMERO CARGAMOS DATOS
		cargarDatos();

		return listaUsuario.isEmpty();
	}

	public HashSet<Usuario> getUsuarios() throws ClassNotFoundException {

		// PRIMERO CARGAMOS DATOS
		cargarDatos();
		return listaUsuario;
	}

	/**
	 * Borra todas los usuarios y comprueba que sea asi
	 * 
	 * @return True si se ha borrado todas los usuarios con existo
	 * @throws ClassNotFoundException
	 *             Error que se lanza cuando no existe la base de datos.
	 */
	public boolean reset() throws ClassNotFoundException {// OK
		cargarDatos();
		ExcepDeleteOnCascade e = new ExcepDeleteOnCascade();
		e.setAceptado(true);
		for (Usuario u : listaUsuario) {
			try {
				borrar(u.getId_u(), e);
			} catch (ExcepDeleteOnCascade e1) {
			}
		}
		cargarDatos();
		boolean dev = false;
		if (listaUsuario.isEmpty()) {
			dev = true;
		}
		return dev;
	}

	public int getId(String quien) throws ClassNotFoundException {
		int id_u = 0;
		cargarDatos();
		for (Usuario u : listaUsuario) {
			if (u.getUsuario().equals(quien)) {
				id_u = u.getId_u();
			}
		}
		return id_u;
	}

	boolean isId(int id) throws ClassNotFoundException {
		boolean esta = false;
		HashSet<Integer> ids;

		objConversor.connect();
		ids = objConversor.listarUsuarioSoloId();
		objConversor.disconnect();

		for (Integer inte : ids) {
			if (inte.intValue() == id) {
				esta = true;
			}
		}
		return esta;
	}

	public Usuario getUsuario(int id) throws FaltanDatosEnLaBaseDeDatos,
			ClassNotFoundException {

		Usuario usu = null;

		cargarDatos();

		for (Usuario u : listaUsuario) {
			if (u.getId_u() == id) {
				usu = u;
			}
		}

		if (usu == null) {

			FaltanDatosEnLaBaseDeDatos f = new FaltanDatosEnLaBaseDeDatos();
			f.setFalta("No existe el usuario en la base de datos");
			throw f;
		}

		return usu;
	}

	public Usuario getUsuario(String usuario)
			throws FaltanDatosEnLaBaseDeDatos, ClassNotFoundException {

		Usuario usu = null;

		cargarDatos();
		for (Usuario u : listaUsuario) {
			if (u.getUsuario().equals(usuario)) {
				usu = u;
			}
		}
		if (usu == null) {
			FaltanDatosEnLaBaseDeDatos f = new FaltanDatosEnLaBaseDeDatos();
			f.setFalta("No existe tal usuario en la Base de datos");
			throw f;
		}
		return usu;
	}

	public boolean isId_i(int id_i) throws ClassNotFoundException {
		cargarDatos();
		Boolean esta = false;
		for (Usuario u : listaUsuario) {
			if (u.getId_i() == id_i) {
				esta = true;
			}
		}
		return esta;
	}
}